package com.sgb.kjwl.view.widget;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;

import androidx.annotation.DrawableRes;

import com.sgb.kjwl.R;
import com.sgb.kjwl.utils.DisplayUtil;
import com.swgk.core.helper.OnMultiClickListener;

/**
 * @author younghow
 * @date 2020/10/28
 * description:这个是针对月我们的头部的一个类，这个类里面定义了一些attr来更新我们的头部
 * first:写在前面,其实对于我们方法来说，是应该不超过八十行来进行设计的，然而在init()方法里面我们
 * 做的属性操作已经导致该方法过于臃肿，其实看过我之前写的东西的同事会认为我又要开始啰嗦泄露
 * 问题，其实在方法里无论多少行都不会造成泄露，为什么需要保证方法的行数是因为需要提高我们代码的
 * 可读性
 * second:第二点，其实在这整个项目会看到形形色色的if没有大括号，其实对于不写大括号，也对编译性能
 * 没有影响，但是也会影响代码的可读性
 * third:第三点，对于比较的先后顺序其实对于Java程序员来说我们的==和=是有区别的，然而对于c程序员这也是
 * 有区别的，然后你认为我在扯淡，其实不是，当我们写if(i=0)在java中会报错，但是在c语言里面是不会的，
 * 为什么呢，首先对于c里面是没有布尔类型的，它的布尔类型是针对于当前的至来说的，大于0是true，反之为
 * false，然后你又要说啦，我就是在扯淡，做安卓不会用到c，首先对于安卓程序员来说，我们的安卓的终点是
 * 对于系统性质的编程进行深入的了解，对于应用层的开发在你进入深层次之后会逐渐淡化，所以，越到后面，对于
 * c/c++更加亲近，这是我们必然会走到的路，那我们现在就应该养成习惯当我们写if(i==0)时，请写成if(0==i)
 * forth:第四点，对于equals，我其实并不知道if(i.equals(“”))比if("".equals(i))的劣势在哪里，这是
 * 阿里的一个规范，但是既然它这样告诉我们，肯定有它一定的道理。
 * fifth：第五点，是及时删除不需要的代码，即注释了的代码。能提高可读性
 */
public class ActionBar extends RelativeLayout implements TextView.OnEditorActionListener {

    /**
     * 返回按钮
     */
    ImageView iconFontBack;
    /**
     * 这个actionbar的主标题
     */
    TextView tvTitle;
    /**
     * 右边的文字按钮
     */
    TextView fontIconLdrtl;
    /**
     * 右边的图标按钮
     */
    private ImageView fivContactSearch;
    /**
     * 本actionbar的输入框
     */
    private EditText editSearch;
    /**
     * 这个其实是输入框的一系列回调，首先是清除(点击删除按钮的清除回调),第二个就是搜索回调，
     * 这个其实是输入法的搜索按钮的回调
     */
    private ClearEdiText clearEdiText;
    /**
     * actionbar输入框里面的删除按钮
     */
    private ImageView ivClose;

    public ClearEdiText getClearEdiText() {
        return clearEdiText;
    }

    public void setClearEdiText(ClearEdiText clearEdiText) {
        this.clearEdiText = clearEdiText;
    }

    @Override
    public void setVisibility(int visibility) {
        super.setVisibility(visibility);
    }

    public ActionBar(Context context) {
        super(context);
        init(context, null);
    }

    public ActionBar(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

    public ActionBar(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        if (attrs != null) {
            TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.ActionBarYoung, 0, 0);
            try {
                LayoutInflater.from(context).inflate(R.layout.action_bar_blue_enterprise, this);

                //回退按钮
                iconFontBack = findViewById(R.id.iv_back);
                //actionbar的标题
                tvTitle = findViewById(R.id.title_view);
                fivContactSearch = findViewById(R.id.map_view);
                //右边的文字
                fontIconLdrtl = findViewById(R.id.right_view);
                int txtColor = attributes.getColor(R.styleable.ActionBarYoung_txtColor, 0);
                tvTitle.setTextColor(txtColor);

                String font = attributes.getString(R.styleable.ActionBarYoung_title);
                tvTitle.setText(font);
                tvTitle.setTextColor(txtColor);

                boolean isVisibleMenu = attributes.getBoolean(R.styleable.ActionBarYoung_isVisibleMenu, false);
                if (isVisibleMenu) {
                    fivContactSearch.setVisibility(VISIBLE);
                } else {
                    fivContactSearch.setVisibility(GONE);
                }

                String menuFont = attributes.getString(R.styleable.ActionBarYoung_menuText);
                if (menuFont == null || "".equals(menuFont)) {
                    menuFont = "保存";
                }
                fontIconLdrtl.setText(menuFont);
                fontIconLdrtl.setTextColor(txtColor);

                int textSize = (int) attributes.getDimension(R.styleable.ActionBarYoung_menuTextSize, 0);
                if (textSize != 0) {
                    fontIconLdrtl.setTextSize(DisplayUtil.px2sp(getContext(), textSize));
                }

                editSearch = findViewById(R.id.edit_search);
                ivClose = findViewById(R.id.iv_close);
                boolean isVisibleEdit = attributes.getBoolean(R.styleable.ActionBarYoung_isVisibleEdit, false);
                setEditVisible(isVisibleEdit);

                String editHint = attributes.getString(R.styleable.ActionBarYoung_editHint);
                if (editHint != null && !"".equals(editHint)){
                    editSearch.setHint(editHint);
                }

                ivClose.setVisibility(GONE);
                editSearch.addTextChangedListener(new TextWatcher() {
                    @Override
                    public void beforeTextChanged(CharSequence s, int start, int count, int after) {

                    }

                    @Override
                    public void onTextChanged(CharSequence s, int start, int before, int count) {

                    }

                    @Override
                    public void afterTextChanged(Editable s) {
                        if ("".equals(editSearch.getText().toString())){
                            ivClose.setVisibility(GONE);
                        } else {
                            ivClose.setVisibility(VISIBLE);
                        }
                    }
                });

                ivClose.setOnClickListener(v -> {
                    editSearch.setText("");
                    if (clearEdiText != null) {
                        clearEdiText.clearEdiText();
                    }
                });


                boolean isVisibleMenuFunction = attributes.getBoolean(R.styleable.ActionBarYoung_isVisibleMenuFunction, false);
                setMenuFunctionVisible(isVisibleMenuFunction);

                boolean titleVisible = attributes.getBoolean(R.styleable.ActionBarYoung_titleVisible, false);
                setTitleVisible(titleVisible);

                editSearch.setOnEditorActionListener(this);

                RelativeLayout relativeLayout = findViewById(R.id.rl_title);
                View view = findViewById(R.id.liuhai_status_view);
                int backgroundColor = attributes.getColor(R.styleable.ActionBarYoung_backColor, 0);
                if (backgroundColor != 0) {
                    relativeLayout.setBackgroundColor(backgroundColor);
                    view.setBackgroundColor(backgroundColor);
                }
            } finally {
                attributes.recycle();
            }
        }
    }

    public void setTitleMenuImg(int originLang) {
        iconFontBack.setImageResource(originLang);
    }


    public void showReturnBack(boolean show){
        iconFontBack.setVisibility(show?View.VISIBLE:View.INVISIBLE);
    }

    public void setTitle(String title) {
        tvTitle.setVisibility(VISIBLE);
        tvTitle.setText(title);
    }

    public void setTitle(int resId) {
        tvTitle.setVisibility(VISIBLE);
        tvTitle.setText(resId);
    }

    public void setEditSearch(String s){
        editSearch.setText(s);
    }

    /**
     * 请注意，这是控制返回键的回调，我们知道对于后面设置的监听会把前面的覆盖，所以在这里也是这个道理，
     * 因为initView的方法调用是在actionbar的实例化之前的，并且设置返回监听也是在相同的地方，这个时候
     * 我们在initView里面的设置返回键的监听是没有用的，请在onCreate里面实现，以此来它写上自己的逻辑
     * 如果希望在initView里面可以调用实现，请将此类移到library模块下，并把实例化的代码移动到baseActivity
     * @param l 设置返回键的监听，因为覆盖的特性，所以我们在后面写的会覆盖前面写的，以此来实现自己的独有逻辑
     */
    public void setOnBackClickListener(OnClickListener l) {
        iconFontBack.setOnClickListener(l);
    }

    public void setMenuClick(View.OnClickListener click) {
        fivContactSearch.setOnClickListener(click);
    }

    public void setMenuIcon(@DrawableRes int drawable) {
        fivContactSearch.setImageResource(drawable);
    }

    public void setMenuVisible(boolean flag) {
        if (flag) {
            fivContactSearch.setVisibility(VISIBLE);
        } else {
            fivContactSearch.setVisibility(GONE);
        }
    }

    public void setMenuFunctionClick(OnMultiClickListener click) {
        fontIconLdrtl.setOnClickListener(click);
    }

    public void setMenuFunctionVisible(boolean isVisibleMenuFunction) {
        if (isVisibleMenuFunction) {
            fontIconLdrtl.setVisibility(VISIBLE);
        } else {
            fontIconLdrtl.setVisibility(GONE);
        }
    }

    public void setMenuFunctionText(String isVisibleMenuFunction) {
        fontIconLdrtl.setText(isVisibleMenuFunction);
    }

    public String getMenuFunctionText() {
        return fontIconLdrtl.getText().toString();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
    }

    public void setEditVisible(boolean isEditVisible) {
        if (isEditVisible) {
            editSearch.setVisibility(VISIBLE);
            ivClose.setVisibility(VISIBLE);
        } else {
            editSearch.setVisibility(GONE);
            ivClose.setVisibility(GONE);
        }
    }

    public void setTitleVisible(boolean isVisibleMenuFunction) {
        if (!isVisibleMenuFunction) {
            tvTitle.setVisibility(VISIBLE);
        } else {
            tvTitle.setVisibility(GONE);
        }
    }

    public String getEditText() {
        return editSearch.getText().toString();
    }

    public interface ClearEdiText {
        void clearEdiText();

        void search();
    }

    public void openSoftInput() {
        editSearch.postDelayed(() -> {
            editSearch.requestFocus();
            InputMethodManager manager = ((InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE));
            if (manager != null) {
                manager.showSoftInput(editSearch, InputMethodManager.SHOW_FORCED);
            }
        }, 1000);
    }

    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_SEARCH || (event != null && event.getKeyCode() == KeyEvent.KEYCODE_ENTER)) {
            clearEdiText.search();
        }
        return false;
    }
}
